home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Libris Britannia 4
/
science library(b).zip
/
science library(b)
/
PROGRAMM
/
DB_CLIPP
/
0769B.ZIP
/
DRAFT2.STD
< prev
next >
Wrap
Text File
|
1987-10-06
|
30KB
|
1,330 lines
Memorandum to: Dbase Community
From: Standards Committee
Date:
Subject: Draft Syntax
This is the Draft 2 syntax, as compiled so far. It sticks
closely to Ashton-Tate's dBASE III Plus as implemented, not as
documented.
Items not resolved in committee are noted with a `?' on the left.
Of course, we solicit your comments and suggestions on the whole
standard, not merely those items.
Please forward your comments to Sharon Davidson at this office.
.pa
Note: the committee formally requested Ashton-Tate's comments on
the use of the term "Standard Dbase" to name the generic
language.
Ashton-Tate withdrew its observer from the committee and is
referring all calls on this subject to its legal department. In
an informal discussion with the committee chairman, an Ashton-
Tate attorney expressed serious concern over the committee's work
infringing on Ashton-Tate's proprietary rights to its dBASE (r)
trademark. A formal letter raising these concerns was promised.
To date, however, that letter has not been received.
We presume that Ashton-Tate will oppose the use of "Standard
Dbase."
.pa
Contents:
1 Purpose
3 Interactive and non-interactive implementations
4 Syntax of this specification
5 Miscellaneous
6 Character set
7 Components of statements
7 Keywords
12 Constants
13 Fields and memory variables
14 Functions
16 Expressions
18 Other components
23 Statements
24 Simple statements
32 Block statements
33 Program statements
34 Programs
.pa
Standard Dbase
Purpose:
During 1978 and 1979 Wayne Ratliff implemented JPLDIS (Jet
Propulsion Laboratories Display and Information System), a
mainframe fourth generation data processing language, on an IMSAI
8080, an early, 8 bit microcomputer. He called this new
implementation Vulcan. In 1980, Wayne entered into a marketing
agreement with Ashton-Tate, a new software publishing firm.
Ashton-Tate renamed the product dBASE II and marketed it with
extraordinary success. The Dbase language has been extended with
each new release of Ashton-Tate's product. While the language is
only one component of the product, it is still a key component.
To date, Ashton-Tate has sold over 1.5 million dBASE products.
Dbase became a de facto standard programming language for data
processing applications on microcomputers. Other companies have
created and successfully marketed implementations of the Dbase
language. Today's Dbase programmer can choose from a range of
excellent compilers and interpreters. Additionally, the Dbase
programmer has access to the broadest range of tools, such as
editors and code generators, available in any fourth generation
language.
The proliferation of Dbase language implementations has led to a
number of inconsistencies between different vendors' products.
These are sometimes extensions to the language, and sometimes
minor variations in syntax. We wish to strongly encourage the
former and eliminate the latter.
To that end, we have created the attached specification of 1987
Standard Dbase for both interactive and non-interactive
implementations of the language. This is one part of a total
process.
Other key parts include a list of current extensions being
considered for inclusion in the language and a list of current
modifications proposed in the standard. Additionally, we have
created the <committee> to continue to accept proposals for
extensions and modifications, disseminate these proposals as
widely as possible and, with as much public input as possible,
make changes to the Standard Dbase specification.
We trust that the benefits of a dynamic standard will encourage
even more widespread use of the Dbase language for data
processing applications on microcomputers. Additionally, we hope
to encourage vendors to make Standard Dbase available on larger
computers, providing, over time, a single language running from
the largest to the smallest computer.
We wish to encourage vendors to extend the language. We expect
that the nature of the proposed addition will sometimes permit
vendors to propose a change prior to the release of a product,
and, in other instances, concurrently with the release of a
product. We strongly urge all vendors to adhere to the syntax in
the proposals for extensions when they implement features already
included in this list.
Finally, we encourage vendors to re-publish the Standard Dbase
specification with their documentation, noting any differences
and extensions.
.pa
Interactive and non-interactive implementations
The language may be implemented for interactive or non-
interactive use. In interactive implementations, a prompt mode
is available which allows the user to enter all simple statements
for immediate execution. Additionally, screen displays may
convey additional infomation, in a manner determined by the
vendor.
Certain commands are only relevant in an interactive
implementation. These are noted. Use of these commands in
systems which may later be run under a non-interactive
implementation may produce erroneous results.
While it has been traditional to implement interactive
interpreters and non-interactive compilers, this need not be the
case. Both interactive compilers and non-interactive
interpreters may be implemented.
Occasional differences between interactive and non-interactive
implementations are noted and should be avoided by programmers
who require portability.
Implementation of the interactive commands, such as BROWSE, are
vendor specific. A program which includes these interactive
statements will provide the functional capability described, but
it should be assumed that all implementations will be different.
.pa
Syntax of this specification:
a | b -- either a or b
[a] -- null or a
[a]... -- 0 or more a's (vendor defined maximums)
[a]..n -- 0 through n a's
<a> -- substitute an instance of a (mandatory)
{ } -- grouping, e.g. ` { a [b] } | c ' is ` a | ab | c '
d -- digit (0-9)
l -- letter (one of A through Z or a through z)
c -- any character (as permitted by the system -- see Character Set)
UPPERCASE -- include as is (in either upper or lowercase)
.pa
Miscellaneous:
The language is not sensitive to upper or lowercase, except in
character strings. For instance, all the following are
equivalent:
DO WHILE
do while
Do While
Tabs and spaces may be used freely between language elements.
Blank lines may be used freely for clarity.
All keywords may be abbreviated to as few as four characters.
Characters following the fourth are, however, significant. The
APPEND statement may be:
APPEND
APPEN
APPE
On the other hand, APPENDING is not equivalent.
Keywords are not reserved. If there is a field named `append',
for instance:
APPEND BLANK
REPLACE append WITH newvalue
is syntactically correct. Again, the capitalization is a
convention not required by the syntax.
Clauses beginning with keywords have been specified in their
conventional order. However, they may be written in any order.
The following are equivalent:
LIST NEXT 20 FOR state = "CA" FIELDS name,zip
LIST NEXT 20 FIELDS name,zip FOR state = "CA"
LIST FOR state = "CA" NEXT 20 FIELDS name,zip
LIST FOR state = "CA" FIELDS name,zip NEXT 20
LIST FIELDS name,zip NEXT 20 FOR state = "CA"
LIST FIELDS name,zip FOR state = "CA" NEXT 20
.pa
Character set:
All characters permitted by the hardware system is available.
The following characters are part of the language syntax and must
have their ASCII byte values:
Letters A-Z and a-z
digits 0-9
+ - * / ( ) ' " & @ # $ ^ = [ ] , ; < > ? ! _
carriage return, line feed, space, tab
A return ( <r> ) is:
CHR(13) | CHR(10) | {CHR13)CHR(10)}
A positive integer ( <n> ) is:
d[d]...
where at least one d is non-zero.
.pa
Components of statements:
Keywords:
A keyword is one of the following, delimited by at least one
space, tab, <r>, beginning or end of file.
?
??
@
*
!
/A
/C
/D
ACCEPT
ADDITIVE
ALIAS
ALL
ALTERNATE
AMERICAN
ANSI
APPEND
ASSIST
AVERAGE
BEFORE
BELL
BLANK
BOTTOM
BRITISH
BROWSE
CALL
CANCEL
CARRY
CASE
CATALOG
CENTURY
CHANGE
CLEAR
COLOR
COMMAND
CONFIRM
CONSOLE
CONTINUE
COPY
COUNT
CREATE
DATABASES
DATE
DEBUG
DECIMALS
DEFAULT
DELETE
DELETED
DELIMITED
DELIMITERS
DEVICE
DIR
DISPLAY
DO
DOHISTORY
DOUBLE
ECHO
EDIT
EJECT
ELSE
ENDCASE
ENDDO
ENDIF
ENDTEXT
ENVIRONMENT
ERASE
ERROR
ESCAPE
EXACT
EXCEPT
EXIT
EXPORT
EXTENDED
FIELDS
FILE
FILTER
FIND
FIXED
FROM
FOR
FORMAT
FRENCH
FUNCTION
GERMAN
GET
GETS
GO
GOTO
HEADING
HELP
HISTORY
IF
IMPORT
INDEX
INSERT
INTENSITY
INTO
ITALIAN
JOIN
LABEL
LAST
LIKE
LIST
LOAD
LOCATE
LOOP
MASTER
MEMORY
MEMOWIDTH
MENUS
MESSAGE
MODIFY
MODULE
NEXT
NOEJECT
NOTE
OFF
ON
ORDER
OTHERWISE
PACK
PARAMETER
PATH
PICTURE
PLAIN
PRINT
PRIVATE
PROCEDURE
PUBLIC
QUERY
QUIT
RANDOM
RANGE
READ
RECALL
RECORD
REINDEX
RELATION
RELEASE
RENAME
REPLACE
REPORT
REST
RESTORE
RESUME
RETRY
RETURN
RUN
SAFETY
SAVE
SAY
SCREEN
SDF
SET
SKIP
SORT
STATUS
STEP
STORE
STRUCTURE
SUM
SUSPEND
TALK
TEXT
TITLE
TO
TOP
TOTAL
TYPE
TYPEAHEAD
UNIQUE
UPDATE
USE
VIEW
WAIT
WHILE
WITH
ZAP
.pa
Constants:
Constants have the following forms:
L -- logical
.T. | .F.
N -- numeric
{ { [+|-]d[d]...[.[d]...] } | { [+|-].d[d]... } }[{E|e}[+|-]n[n[n]]]
C -- character string
'[c]..254' | "[c]..254" | [[c]..254]
(in the last case, the outer brackets are read literally, e.g.
[string] == "string" )
U -- unquoted string
[c]...
where no c is a space, tab, return or linefeed.
F -- filename
as defined by the operating system
.pa
Fields and memory variables:
(`var' is used to imply either, `field' or `memvar' is used when
appropriate.)
Types:
varD -- Date
varL -- Logical
varN -- Numeric
varC -- Character string
fieldM -- Memo field
Memory variable name:
[M->]l[d|l|_]..10
delimited with space, tab, <r>, beginning or end of file,
expression operator or comma.
The tenth character following the `l' is not significant.
Field name:
[{A|B|C|D|E|F|G|H|I|J|<alias>}->]l[d|l|_]..10
delimited with space, tab, <r>, beginning or end of file,
expression operator or comma.
The tenth character following the `l' is not significant.
.pa
Functions:
Types:
funD -- Date
funL -- Logical
funN -- Numeric
funC -- Character string
funS -- Source code
Returns
S &<memvar> -- the contents of <memvar> are substituted in the source code
N ABS(<expN>) -- absolute value of expN
N ASC(<expC>) -- ASCII code for first letter of expC
N AT(<expC1>,<expC2>) -- location of expC1 within expC2, or 0
L BOF() -- .true. if beginning of file
C CDOW(<expD>) -- day of week as a string ("Tuesday")
C CHR(<expN>) -- ASCII character (expN must be 0 to 255)
C CMONTH(<expD>) -- name of month as a string ("July")
N COL() -- column location of cursor
D CTOD(<expC>) -- converts expC, in form "mm/dd/yy" to date
D DATE() -- system date
N DAY(<expD>) -- day of month
C DBF() -- name of the database file in use (or null string)
L DELETED() -- .true. if record is marked for deletion
N DISKSPACE() -- available diskpace, in bytes
N DOW(<expD>) -- day of week (Sunday = 1)
C DTOC(<expD>) -- date to "mm/dd/yy" format string
L EOF() -- .true. if end of file
N ERROR() -- error number trapped by ON ERROR condition
N EXP(<expN>) -- 2.718... to the expN power
C FIELD(<expN>) -- name of the expNth field in the current DBF (or null)
L FILE(<expC>) -- .true. if expC names a file
C FKLABEL(<expN>) --
N FKMAX() -- maximum number of special function keys
L FOUND() -- .true. if last FIND, SEEK, LOCATE or CONTINUE succeeded.
C GETENV(<expC>) -- OS's environment variables
varies IIF(<expL>,<exp1>,<exp2>) -- if expL, exp1, else exp2
N INKEY() -- gets character from keyboard buffer
N INT(<expN>) -- truncates to integer ( 12.5 -> 12, -12.5 -> -12 )
L ISALPHA(<expC>) -- .true. if first character in expC is alphabetic
L ISCOLOR() -- .true. for color mode, .false. for monochrome
L ISLOWER(<expC>) -- .true. if first character of expC is lowercase
C LEFT(<expC>,<expN>) -- leftmost expN characters of expC
N LEN(<expN>) -- length of string
N LOG(<expN>) -- natural logarithm
C LOWER(<expC>) -- expC in all lowercase
C LTRIM(<expC>) -- expC without leading blanks
D LUPDATE() -- date of last update of current DBF
N MAX(<expN1>,<expN2>) -- greater of expN1 and expN2
C MESSAGE() -- error message
N MIN(<expN1>,<expN2>) -- lesser of expN1 and expN2
N MOD(<expN1>,<expN2>) -- expN1 modulo expN2
N MONTH(<expD>) -- month
C NDX(<expN>) -- name of the expNth index (1 through 7) open with
current DBF
C OS() -- name of the operating system
N PCOL() -- current printer column
N PROW() -- current printer row
N READKEY() -- the key used to exit from full screen input
N RECCOUNT() -- number of records in current DBF
N RECNO() -- current record number
N RECSIZE() -- size of record, in bytes, in current DBF
C REPLICATE(<expC>,<expN>) -- repeats expC, expN times
C RIGHT(<expC>,<expN>) -- rightmost expN characters of expC
N ROUND(<expN1>,<expN2>) -- expN1 rounded to expN2 decimal places
N ROW() -- current screen cursor row
C RTRIM(<expC>) -- same as TRIM
C SPACE(<expN>) -- string of expN spaces
N SQRT(<expN>) -- square root of expN
C STR(<expN1>[,<expN2>[,<expN3]]>)
expN1 as string, expN2 long, expN3 decimal places
C STUFF(<expC1>,<expN1>,<expN2>,<expC2>)
stuff expC2 into expC1 at expN1 dropping expN2 characters
C SUBSTR(<expC>,<expN1>[,<expN2]>)
expC from character expN1 for expN2 characters
C TIME() -- system times in hh:mm:ss format
C TRANSFORM(<exp>,<pic>) -- exp formatted according to picllll
C TRIM(<expC>) -- expC without trailing blanks
C TYPE(<'expC'|expC>) -- type (C, D, L, N, U=unknown) of 'expC'
or expC's contents
C UPPER(<expC>) -- expC in all uppercase
N VAL(<expC>) -- the numeric value of expC, or 0 if not numeric
C VERSION() -- name of current Dbase version
N YEAR(<expD>) -- year, e.g. 1987
.pa
Expressions:
An expression has one of the following types:
expD -- Date
expL -- Logical
expN -- Numeric
expC -- Character string
expX -- date or numeric or character string (eXcept logical)
An expression has the following form:
[ {+|-|.NOT.} ] { { <constant> | <var> | <fun> | <expression> }
[ <operator> <expression> ] } | ( <expression> )
Operators are:
Mathematical and string (in order of precedence):
+, - unary plus, negation
**, ^ exponentiation
*, / multiplication, division
+, - addition, subtraction, or string contatenation
Comparison (no precedence):
< less than
<= less than or equal to
= equal to
>= greater than or equal to
> greater than
<>, # not equal to
$ substring ( a$b returns true if a is a substring in b )
Logical (in order of precedence):
.NOT. logical not
.AND. logical and
.OR. logical or
.pa
Valid expression/operator combinations are:
.NOT. <expL>
[+|-] <expN>
<expN> <mathematical> <expN>
<expC> {+|-} <expC>
<expD> <comparison> <expD>
<expN> <comparison> <expN>
<expC> <comparison> <expC>
<expL> { .AND. | .OR. } <expL>
<expD> - <expD>
<expD> { + | - } <expN>
<expN> + <expD>
The type of an expression may differ from the type of its
components, as in:
.NOT. 2 + 2 <> 4
Precedence in evaluation is:
Within parentheses
Mathematical and string (as specified)
Comparison
Logical (as specified)
Evaluation is left to right if not otherwise specified.
.pa
Other components of statements
Coordinates:
The screen is addressed by character sized rows and columns. Row
0, column 0 is the upper left. <coord> is specified by:
<expN1>,<expN2>
Pictures:
Picture clauses format output and restrict input. A <pic> is:
PICTURE { { <functions>[<template>] } | <template> }
<functions> are one or more symbols from the following list:
A -- alphabetic characters only
B -- left justify numberss
C -- display CR after positive numbers
D -- American date format
E -- European date format
R -- literals in the template are not part of the data
S<n> -- scroll field within n characters
X -- display DB after negative numbers
Z -- display all blanks for a zero value
! -- capital letters only
( -- enclose negative numbers in parentheses
.pa
A <template> is a string composed of the following:
A -- letters only
L -- logical value only
N -- letters or digits
X -- any character
Y -- Y, y, N or n only, with conversion to uppercase
9 -- digits only (leading sign allowed in numbers)
! -- as X plus convert lowercase to uppercase
# -- digit or sign or blank
$ -- show `$' for leading zeros.
* -- show `*' for leading zeros.
, -- comma (suppressed on left)
. -- decimal point
x -- all other characters are constants
Lists:
A list of x's, e.g. field list, has the following form:
<x> [,x]...
Filename:
A <filename> is:
An unquoted character string recognized by the operating system
as naming a logical file.
Alias:
An <alias> is:
<filename> | {var name}
File specification:
A <file spec> is:
An unquoted character string recognized by the operating system
as specifying a group of files.
Skeletons:
A <skeleton> is an unquoted character string used by the
operating system as part of a <file spec>. For instance: a?b*,
in DOS.
OS commands:
An <OS command> is an unquoted character string which is a valid
command to the operating system.
Storage areas:
A <storage area> is:
An unquoted string naming a logical or physical area for data
storage, as defined by the operating system. For instance, C: or
\path\ in DOS.
OS devices:
An <OS device> is:
An unquoted string naming a logical or physical input/output
device, as defined by the operating system.
Procedure name:
A <procedure name> is:
<filename> | <var name>
Date type:
A <date type> is:
AMERICAN | ANSI | BRITISH | FRENCH | GERMAN | ITALIAN
Filetype:
A <type> is an unquoted string from a vendor defined list.
Type clause:
A <type clause> is:
{ TYPE <type> } | { SDF [ DELIMITED [ WITH {SPACE|c} ] ] }
Scopes:
A scope clause controls the range of operation of some commands.
A <scope> is:
ALL | { NEXT <n> } | { RECORD <expN> } | REST
Condition clause:
A condition clause is:
{ WHILE <expL> [ FOR <expL> ] } | { FOR <expL> [ WHILE <expL> ] }
Scope & condition:
A <scope & condition> is one, two or all of:
<scope>
WHILE <expL>
FOR <expL>
Get clause:
A <get> is:
{ GET <var> [<pic>] } |
{ GET <varN> [<pic>] [RANGE <expN1,expN2>] } |
{ GET <varD> [<pic>] [RANGE <expD1,expD2>] }
Comments:
A comment is any character string. Comments are ignored.
.pa
Statements:
A <statement> is:
{ c[c]..253 <r> } | { c[c]..251 && [comment] <r> }
in one of the following forms.
If the statement is a comment (* or NOTE) the remaining
characters are ignored.
? Note: This gives `*' precedence over `;'. Continuing a comment
requires a new `*' -- unlike Ashton-Tate's implementation.
If the last non-whitespace character is a `;' the `;', whitespace
and return are ignored. (The statement continues on the next line.)
Characters following `&&' are ignored (available for comments).
All statements, except the alternate form of STORE, start with a
keyword.
A <statement name> is the keyword which begins the statement.
Both:
STORE <exp> TO <memvar> and
<memvar> = <exp>
are considered as a STORE statement.
A <statement> is:
<simple statement> | <block statement> | <program statement>
.pa
A <simple statement> is one of the following:
? <exp list>
Output CR/LF and the value of the expressions.
?? <exp list>
Output the value of the expressions.
@ <coord> CLEAR TO <coord>
@ <coord> <get>
@ <coord> SAY <exp> [<pic>] [ <get> ]
@ <coord> TO <coord> [DOUBLE]
ACCEPT [<expC>] TO <memvar>
APPEND
interactive
APPEND BLANK
APPEND FROM <filename> [<scope>] [<type clause>]
ASSIST <command list>
interactive
AVERAGE <exp list> [<scope & condition>] [TO <memvar list>]
BROWSE
interactive
CALL <filename> [ WITH { <expC> | <memvar> } ]
interactive
CANCEL
interactive differs from non-interactive
CHANGE [<scope & condition>] [FIELDS <field list>]
CLEAR [ { ALL | FIELDS | GETS | MEMORY | TYPEAHEAD } ]
CLOSE { ALL | ALTERNATE | DATABASES | FORMAT | INDEX | PROCEDURE }
CONTINUE
COPY FILE <filename> TO <filename>
COPY STRUCTURE TO <filename> [ FIELDS <field list> ]
COPY TO <filename> [ <scope & condition> ] [FIELDS <field list>
[<type clause>]
COPY TO <filename> STRUCTURE EXTENDED
COUNT [ <scope & condition> ] [ TO <memvar> ]
CREATE <filename>
CREATE <filename> FROM <filename>
CREATE { LABEL | QUERY | REPORT | SCREEN | VIEW } <filename>
CREATE VIEW <filename> FROM ENVIRONMENT
interactive
DELETE [ <scope & condition> ]
DELETE FILE <filename>
DIR <file spec>
interactive
DISPLAY [ <scope & condition> ] [ <exp list> ] [OFF] [TO PRINT]
DISPLAY { { HISTORY [LAST <expN>] } | MEMORY | STATUS | STRUCTURE }
[TO PRINT]
interactive
DO <procedure name> [20WITH <parameter list> ]
EDIT [ <scope & condition> ] [FIELDS <field list>]
interactive
EJECT
ERASE <filename>
EXPORT TO <filename> [ TYPE <type> ]
FIND <character string> | <n>
GO[TO] { BOTTOM | TOP | <expN> }
HELP [<keyword>]
interactive
IMPORT FROM <filename> TYPE <type>
INDEX ON <expX> TO <filename> [ UNIQUE ]
? The INPUT statement is omitted
INSERT [BEFORE]
interactive
INSERT BLANK [BEFORE]
JOIN WITH <alias> TO <newfile> FOR <expL> [ FIELDS <field list> ]
LABEL FORM <filename> [<scope & condition>] [NOEJECT]
[ { { TO PRINT } | { TO FILE <filename> } } ]
LIST [ <scope & condition> ] [ <exp list> ] [OFF] [TO PRINT]
LIST { { HISTORY [ LAST <expN> } | MEMORY } [ TO PRINT ]
interactive
LIST { STATUS | STRUCTURE }
interactive
LOAD <filename>
LOCATE [ <scope & condition> ]
LOOP -- see DO WHILE
MODIFY { STRUCTURE | ENVIRONMENT }
interactive
MODIFY { COMMAND | LABEL | QUERY | REPORT | SCREEN | VIEW } <filename>
interactive
{ NOTE | * } [comment]
ON { ERROR | ESCAPE } <simple statement>
PACK
PRIVATE [ ALL [ { LIKE | EXCEPT } <skeleton> ] ] | [ <memvar list> ]
PUBLIC <memvar list>
QUIT
READ [SAVE]
RECALL [ <scope & condition> ]
REINDEX
RELEASE <memvar list> | { ALL [ { LIKE | EXCEPT } <skeleton> ] } |
{ MODULE <module name> }
RENAME <filename> TO <filename>
REPLACE [ <scope & condition> ] <field> WITH <exp> [, <field> WITH <exp> ]...
REPORT FORM <filename> [ <scope & condition> ] [ PLAIN ] [ HEADING <expC> ]
[ NOEJECT ] [ { { TO PRINT } | { TO FILE <filename> } } ]
RESTORE FROM <filename> [ ADDITIVE ]
RESUME
interactive
RETRY
RETURN [ TO MASTER ]
{ RUN | ! } < OS command >
SAVE TO <filename> [ALL { LIKE | EXCEPT } <skeleton> ]
SET { ALTERNATE | (boldface)BELL | CARRY | (boldface)CATALOG | CENTURY |
CONFIRM | (boldface)CONSOLE | DEBUG | DELETED | DELIMITERS | DOHISTORY |
ECHO | (boldface)ESCAPE | EXACT | FIELDS | FIXED | (boldface)HEADING |
(boldface)HELP | (boldface)HISTORY | (boldface)INTENSITY | (boldface)MENUS |
PRINT | (boldface)SAFETY | (boldface)STATUS | STEP | (boldface)TALK |
(boldface)TITLE | UNIQUE } { ON | OFF }
(boldface)Boldface = default is ON. CARRY, CATALOG, DEBUG, DOHISTORY, ECHO,
HELP, HISTORY, MENUS, SAFETY, STATUS, STEP, TALK and TITLE are interactive.
SET { ALTERNATE | CATALOG | FORMAT | PROCEDURE | VIEW } TO <filename>
CATALOG is interactive.
SET COLOR TO [ <standard> [, <enhanced> [, <border> ] ] ]
SET DATE <date type>
SET { DECIMALS | MEMOWIDTH | ORDER | TYPEAHEAD } TO <expN>
SET DEFAULT TO <storage area>
SET DELIMITERS TO { <expC> | DEFAULT }
SET DEVICE TO { SCREEN | PRINT }
SET FIELDS TO { <field list> | ALL }
SET FILTER TO [ { FILE <filename> } | <expL> ]
? Under the Ashton-Tate interpreter, the keyword TO may be
omitted to turn a filter off.
SET FUNCTION <expC> TO <expC>
SET INDEX TO [ <file list> ]
SET MESSAGE TO <expC>
interactive
SET PATH TO <storage area list>
SET PRINTER TO { <OS device> | <filename> }
SET RELATION TO [ { <expX> | <expN> } INTO <alias> ]
SKIP [ <expN> ]
SORT TO <filename> ON <field> [/A] [/C] [/D] [, <field> [/A] [/C] [/D] ]...
{ STORE <exp> TO <memvar list> } | { <memvar> = <exp> }
SUM [ <scope> ] [ <exp list> ] TO [ <memvar list> ] [ <condition clause> ]
SUSPEND
interactive
TOTAL TO <filename> ON <key> [ <scope & condition> ] [ FIELDS <field list> ]
TYPE <filename> [ TO PRINT ]
UPDATE ON <expX> FROM <alias> REPLACE <field> WITH <exp> [, <field> WITH
<exp> ]... [RANDOM]
USE [ <filename> [ INDEX <file list> ] [ ALIAS <alias> ] ]
WAIT [ <expC> ] [ TO <memvar> ]
ZAP
.pa
Block statements:
Block statements are one of the following:
(<statements>, as used below, means any combination of simple and
block statements.
DO CASE
CASE <expL>
<statements>
[CASE <expL2>
<statements>]...
[OTHERWISE [comment]
<statements>]
ENDCASE [comment]
DO WHILE <expL>
statements
[ LOOP
statements]
[ EXIT [comment] ]
[statements]
ENDDO [comment]
LOOP and EXIT lines may appear repeatedly and in any order.
IF <expL>
<statements>
[ ELSE
<statements> ]
ENDIF [comment]
TEXT
[c]...
ENDTEXT
The characters here may include <r> characters.
.pa
Program statement:
Program statements are one of the following:
PARAMETER <memvar list>
PROCEDURE <procedure name>
.pa
Programs:
As used here, <statements> means any combination of simple and
block statements.
{ { beginning of file } | [ <PROCEDURE statement> ] }
[ <PARAMETER statement> ]
<statements>
The program ends with the last statement prior to another
PROCEDURE statement, or with the end of the file.
The simple statements CANCEL, RETURN and QUIT may appear anywhere
in the statements portion of the program.